/*
* 设备类型管理模块
*/
const express = require('express');
const router = express.Router();
// 引入数据库
const db = require("../../../config/db");
// 引入时间包
const moment = require("moment");
// 引入方法库
const { toCamelCase, toUnderlineCase, verifyToken} = require("../../../config/utils");
// 引入日志
const log = require("../../log");

// 查询设备类型列表
router.get('/list', async (req, res) => {
    console.log("===========查询设备类型列表接口============");
    // 获取参数
    let { machineryTypeName, enableFlag } = req.query;
    // 拼接sql语句
    let sql = "select * from dv_machinery_type";
    let sql_where = ` where 1=1`;
    if(machineryTypeName){
        sql_where += ` and machinery_type_name like '%${machineryTypeName}%'`;
    }
    if(enableFlag){
        sql_where += ` and enable_flag = '${enableFlag}'`;
    }
    if(machineryTypeName || enableFlag ){
        sql += sql_where;
    }
   
    // 查询数据库
    db.query("查询设备类型列表", sql, (err, result)=>{
        if(err){
            res.send({code: 500, msg: "查询设备类型列表失败", data: err});
            return;
        }
        if(result.length > 0){
            // 变量Json数组key转成下划线第一个大写
            result = result.map(item => {
               return toCamelCase(item)
           })
           res.send({code: 200, msg: "查询设备类型列表成功", data: result});
       }else{
           res.send({code: 200, msg: "查询设备类型列表成功", data: [], total: 0});
       }
    })
})

// 新增设备类型列表
router.post('/', (req, res) => {
    console.log("===========新增设备类型列表接口============");
    // 获取token的创建人
    let {username} = verifyToken(req.headers.authorization);
    // 获取参数
    let {enable_flag, machinery_type_name, parent_type_id, remark, machinery_type_id} = toUnderlineCase(req.body);
    // 获取创建时间
    let create_time = moment().format("YYYY-MM-DD HH:mm:ss");
   
    // 查询同级别设备类型名称是否重复
    db.query("查询同级别设备类型名称是否重复", `select * from dv_machinery_type where machinery_type_name = '${machinery_type_name}' and parent_type_id ='${parent_type_id}'`, (err, result) => {
        if (err) {
            res.send({code: 500, msg: '查询同级别设备类型名称是否重复失败', data: err})
            return
        }
        if(result.length > 0) {
            res.send({code: 500, msg: `当前同级别设备类型名称-${machinery_type_name}-重复`})
            return
        }

         // 查询数据库有几条数据生成id 联合查询 查询父类层级
        let sql_union = `select count(*) from dv_machinery_type union all SELECT ancestors from dv_machinery_type where machinery_type_id = ${parent_type_id}`
        db.query("查询数据库有几条数据生成id  联合查询 查询父类层级", sql_union, (err, result) => {
            if (err) {
                res.send({ msg: "查询数据库有几条数据生成id失败",  code: 500, data: err })
                return
            }
            // 生成id
            let machinery_type_id = Number(result[0]['count(*)']) + 1;
            // 生成id的code：M_TYPE_0000
            // 补零
            if( machinery_type_id < 10){
                machinery_type_id = "00" + machinery_type_id;
            }else if(machinery_type_id < 100){
                machinery_type_id = "0" + machinery_type_id;
            }
            let machinery_type_code = `M_TYPE_${machinery_type_id}`;
            // 父类层级
            let ancestors = result[1]['count(*)'] ? result[1]['count(*)'] + ',' + parent_type_id : result[1]['count(*)'];
            // 生成sql
            let sql = `insert into dv_machinery_type (machinery_type_id, machinery_type_code, enable_flag, machinery_type_name, parent_type_id, create_time, create_by, ancestors, remark)
            values ('${machinery_type_id}', '${machinery_type_code}', '${enable_flag}', '${machinery_type_name}', '${parent_type_id}', '${create_time}', '${username}' ,'${ancestors}', ${remark ? "'"+remark+"'" : null})`;
            // 查询数据库
            db.query("新增设备类型表", sql, (err, result) => {
                if (err) {
                    res.send({ msg: "新增设备类型表失败",  code: 500, data: err})
                    return
                }
                if(result.affectedRows > 0) {
                    res.send({code:200, msg: '新增成功',data:1})
                }else{
                    res.send({code:500, msg: '新增失败',data:0})
                }
            })
        })
    })
   
})

// 查询单个设备类型表
router.get(/^\/(\d+)$/, (req, res) => {
    console.log("===========查询单个设备类型表接口，正则匹配============");
    let url_arr = req.url.split("/");
    const machinery_type_id = url_arr[url_arr.length - 1];
    // 查询数据库
    db.query("查询单个设备类型表", `select * from dv_machinery_type where machinery_type_id = '${machinery_type_id}'`, (err, result) => {
        if (err) {
            res.send({code: 500, msg: '查询单个设备类型表失败', data: err})
            return
        }
        if(result.length > 0) {
           // 变量Json数组key转成下划线第一个大写
            result = result.map(item => {
                item.params = {};
                item.children = [];
                return toCamelCase(item)
            })
            result = result[0]
        }
        res.send({
            code: 200,
            msg: '查询成功',
            data: result
        })
    })
    
})

// 修改设备类型表 不重复导致不能修改层级
router.put('/', (req, res) => {
    console.log("===========修改设备类型表接口============");
    // 判断有没有权限(只判断账号admin，和后续优化)
    let {username} = verifyToken(req.headers.authorization)
    if(username != 'admin') {
        res.send({code: 400, msg: '没有权限，请联系管理员授权'})
        return
    }
    // 获取参数
    let {machinery_type_name, enable_flag, machinery_type_id, parent_type_id, remark} = toUnderlineCase(req.body);
    // 更新时间
    let update_time = moment().format('YYYY-MM-DD HH:mm:ss');
    // 查询同级别名称是否重复
    db.query("查询同级别名称是否重复", `select * from dv_machinery_type where machinery_type_name = '${machinery_type_name}' and machinery_type_id != ${machinery_type_id} and parent_type_id ='${parent_type_id}'`, (err, result) => {
        if (err) {
            res.send({code: 500, msg: '查询同级别名称是否重复失败', data: err})
            return
        }
        if(result.length > 0) {
            res.send({code: 500, msg: `当前同级别分类名称-${machinery_type_name}-重复`})
            return
        }
        
        // 更新数据库
        db.query("修改设备类型表", `update dv_machinery_type set machinery_type_name = '${machinery_type_name}', 
        enable_flag = '${enable_flag}', remark=${remark ? "'"+remark+"'" : null}, update_time = '${update_time}',
        update_by = '${username}' where machinery_type_id = '${machinery_type_id}'`, (err, result) => {
            if (err) {
                res.send({code: 500, msg: '修改设备类型表失败', data: err})
                return
            }
            if(result.affectedRows > 0) {
                res.send({ code: 200, msg: '修改成功', data: result })
            } else {
                res.send({ code: 500, msg: '修改失败' })
            }
        })
    })

})

// 删除设备类型表
router.delete('/:machinery_type_id', (req, res) => {
    console.log("===========删除设备类型表接口============");
    // 判断有没有权限(只判断账号admin，和后续优化)
    let {username} = verifyToken(req.headers.authorization)
    if(username != 'admin') {
        res.send({code: 400, msg: '没有权限，请联系管理员授权'})
        return
    }
    // 获取参数
    let {machinery_type_id} = req.params;
    // 查询是否存在子类型
    db.query("查询是否存在子类型", `select * from dv_machinery_type where ancestors like '%${machinery_type_id}%'`, (err, result) => {
        if (err) {
            res.send({code: 500, msg: '查询是否存在子类型失败', data: err})
            return
        }
        if(result.length > 0) {
            res.send({code: 500, msg: '存在子类型，无法删除，请先删除子类型'})
            return
        }
        // 删除数据库
        db.query("删除设备类型表", `delete from dv_machinery_type where machinery_type_id = '${machinery_type_id}'`, (err, result) => {
            if (err) {
                res.send({code: 500, msg: '删除设备类型表失败', data: err})
                return
            }
            if(result.affectedRows > 0) {
                res.send({ code: 200,msg: '删除成功', data: result })
            }else {
                res.send({ code: 500, msg: '删除失败' })
            }
        })
    })
})


module.exports = router;